home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 145 / Gekkan Dennou Club - 2000.6 Vol. 145 (Japan).7z / Gekkan Dennou Club - 2000.6 Vol. 145 (Japan) (Track 1).bin / tools / sharp / sxwork3.lzh / ｻﾝﾌﾟﾙ応用編 / 簡易ドロー / SDRAW.C < prev    next >
Text File  |  1994-03-10  |  38KB  |  1,317 lines
  1. /******************************************************************************
  2.  *    sdraw.c:    ドロー編集の処理関数
  3.  ******************************************************************************
  4.  *    Workroom SX-68K Sample Program Copyright 1994 SHARP
  5.  */
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <sxmemory.h>        /* メモリマンを利用するときに必要    */
  9. #include <event.h>        /* イベントマンを利用するときに必要    */
  10. #include <sxgraph.h>        /* グラフ系マネージャを利用するときに必要 */
  11. #include <dialog.h>        /* ダイアログマンを利用するときに必要    */
  12. #include "sdraw.h"        /* このプログラム固有のヘッダファイル    */
  13.  
  14. /******************************************************************************
  15.  *    drawAll():    ウィンドウ内部全体の描画
  16.  ******************************************************************************
  17.  *    引数:    ComVal *pcv    共通変数へのポインタ
  18.  */
  19. void drawAll(ComVal *pcv)
  20. {
  21.     /* dataを元に描画されたすべての図形の描画を行う */
  22.     drawNext(pcv, pcv->data);
  23.     /* アクティブ図形にハンドルを表示する */
  24.     if (pcv->actData != NULL)
  25.         /* 図形の移動または拡大／縮小時以外のときハンドルを表示する */
  26.         if (!(pcv->drawType == 8 && pcv->selMode != -1))
  27.             dispHdlRect(pcv, (*pcv->actData)->id);
  28. }
  29.  
  30. /******************************************************************************
  31.  *    drawNext():    現在描画されている図形をすべて描画
  32.  ******************************************************************************
  33.  *    引数:    ComVal *pcv    共通変数へのポインタ
  34.  *        ComData **hcd    描画図形のデータハンドル
  35.  */
  36. void drawNext(ComVal *pcv, ComData **hcd)
  37. {
  38.     /* 一番最初に描画された図形データから描画を行う */
  39.  
  40.     /* 指定図形データのハンドルがNULLならば処理終了 */
  41.     if (hcd == NULL)
  42.         return;
  43.  
  44.     /* １つ前のデータのハンドルを渡して図形の描画を行う */
  45.     drawNext(pcv, (*hcd)->next);
  46.     /* 移動または拡大処理中でかつ指定のハンドルが選択図形のときの処理 */
  47.     if (pcv->drawType == 8 && pcv->selMode != -1 && pcv->actData == hcd)
  48.         return;
  49.  
  50.     /* 実際のデータの描画を行う */
  51.     drawOne(pcv, hcd);
  52. }
  53.  
  54. /******************************************************************************
  55.  *    drawOne():    指定された図形データの描画
  56.  ******************************************************************************
  57.  *    引数:    ComVal *pcv    共通変数へのポインタ
  58.  *        ComData **hcd    描画図形のデータハンドル
  59.  */
  60. void drawOne(ComVal *pcv, ComData **hcd)
  61. {
  62.     ComData **temp;
  63.  
  64.     /* 指定図形データのペンサイズに設定する */
  65.     GMPenSize((*hcd)->penSize.x_y);
  66.     /* 指定図形データの描画色に設定する */
  67.     GMForeColor((*hcd)->color);
  68.  
  69.     /* 図形の種類が多角形ではないとき */
  70.     if ((*hcd)->id >= 1 && (*hcd)->id <= 4)
  71.         /* 図形の種類および描画モードによって描画を行う */
  72.         drawZukei(pcv, (*hcd)->id, (*hcd)->drawMode, &(*hcd)->bounds);
  73.     /* 多角形のとき */
  74.     else {
  75.         temp = pcv->actData;
  76.         pcv->actData = hcd;
  77.         /* 描画モードによって多角形の描画を行う */
  78.         drawZukei(pcv, 8, (*hcd)->drawMode, &(*hcd)->bounds);
  79.         pcv->actData = temp;
  80.     }
  81. }
  82.  
  83. /******************************************************************************
  84.  *    setInpRgnPos():    多角形処理中のマウスレフトダウンイベント処理
  85.  ******************************************************************************
  86.  *    引数:    ComVal *pcv    共通変数へのポインタ
  87.  */
  88. void setInpRgnPos(ComVal *pcv)
  89. {
  90.     Point pt;
  91.  
  92.     /* メインウィンドウをカレントグラフにする */
  93.     GMSetGraph(&pcv->windowPtr->graph);
  94.  
  95.     /* 入力座標をローカル座標系に変換する */
  96.     pt.x_y = GMGlobalToLocal(pcv->event.ev.where.x_y);
  97.     /* 取得座標が画面を外れてないかチェックする */
  98.     checkPos(pcv, &pt);
  99.     /* downPosに入力座標を設定 */
  100.     pcv->downPos = pt;
  101.     if (pcv->rgnCnt == 0) {
  102.         pcv->rbSize.l.l_t = pt.x_y;
  103.         pcv->rbSize.l.r_b = pt.x_y;
  104.     }
  105.     /* 入力がダブルクリックかどうかをチェックする */
  106.     if (checkDClick(pcv))
  107.         /* ダブルクリックのときリージョン終了 */
  108.         /* pcv->animFlagを２にする */
  109.         pcv->animFlag = 2;
  110.     /* リージョンの描画を行う */
  111.     drawGraph(pcv);
  112. }
  113.  
  114. /******************************************************************************
  115.  *    setComData():    登録時の共通データの設定
  116.  ******************************************************************************
  117.  *    引数:    ComVal *pcv    共通変数へのポインタ
  118.  *        ComData **hcd    登録の共通データポインタ
  119.  *    注釈:
  120.  *    図形登録時の共通データ部分の設定を行う。
  121.  *    また、データを登録したハンドルの確保を行う。
  122.  */
  123. void setComData(ComVal *pcv, ComData **hcd)
  124. {
  125.     ComData **temp;
  126.  
  127.     /* 図形種別の設定 */
  128.     (*hcd)->id = pcv->drawType;
  129.     /* 描画色の設定 */
  130.     (*hcd)->color = pcv->paletFC;
  131.     /* 描画ペンサイズの設定 */
  132.     (*hcd)->penSize = pcv->penSize;
  133.     /* 描画モードの設定 */
  134.     (*hcd)->drawMode = pcv->drawMode;
  135.  
  136.     /* データを登録したハンドルの確保を行う */
  137.  
  138.     /* データが１件も登録されていないとき */
  139.     if (pcv->dataCnt == 0 && pcv->data == NULL) {
  140.         (*hcd)->next = NULL;
  141.         pcv->data = hcd;
  142.     /* すでに登録されたデータが存在するとき */
  143.     } else {
  144.         temp = pcv->data;
  145.         pcv->data = hcd;
  146.         (*hcd)->next = temp;
  147.     }
  148.  
  149.     /* 登録データ数を更新する */
  150.     pcv->dataCnt++;
  151.  
  152.     /* ハンドルを消去する */
  153.     if (pcv->actData != NULL)
  154.         dispHdlRect(pcv, (*pcv->actData)->id);
  155.  
  156.     /* カレント図形のハンドルを設定する */
  157.     pcv->actData = pcv->data;
  158.  
  159.     /* カレント図形の表示を行う */
  160.     if ((*hcd)->id >= 1 && (*hcd)->id <= 4)
  161.         /* 図形の描画を行う */
  162.         drawZukei(pcv, pcv->drawType, pcv->drawMode, &(*hcd)->bounds);
  163.     else {
  164.         /* 入力された多角形の描画を行う */
  165.         drawZukei(pcv, 8, pcv->drawMode, &(*hcd)->bounds);
  166.         /* リージョン処理フラグをオフにする */
  167.         pcv->rgnCnt = 0;
  168.     }
  169.  
  170.     /* 描画フラグをクリアする */
  171.     pcv->animFlag = 0;
  172.  
  173.     /* カレント図形のハンドルの設定および表示を行う */
  174.     dispCurHdl(pcv);
  175. }
  176.  
  177. /******************************************************************************
  178.  *    dispCurHdl():    カレント図形のハンドルの設定および表示
  179.  ******************************************************************************
  180.  *    引数:    ComVal *pcv    共通変数へのポインタ
  181.  */
  182. void dispCurHdl(ComVal *pcv)
  183. {
  184.     int i;
  185.     Rect rc, rch;
  186.     ComData **hcd = pcv->actData;
  187.  
  188.     rc = (*hcd)->bounds;
  189.     if ((*hcd)->id == 1) {
  190.         pcv->rcHandle[0].d.left = rc.d.left - 2;
  191.         pcv->rcHandle[0].d.top = rc.d.top - 2;
  192.         pcv->rcHandle[0].d.right = rc.d.left + 2;
  193.         pcv->rcHandle[0].d.bottom = rc.d.top + 2;
  194.         pcv->rcHandle[1].d.left = rc.d.right - 2;
  195.         pcv->rcHandle[1].d.top = rc.d.bottom - 2;
  196.         pcv->rcHandle[1].d.right = rc.d.right + 2;
  197.         pcv->rcHandle[1].d.bottom = rc.d.bottom + 2;
  198.  
  199.         /* ハンドルを描画する */
  200.         dispHdlRect(pcv, (*hcd)->id);
  201.         return;
  202.     }
  203.     for (i = 0; i < 8; i++) {
  204.         rch = pcv->rcHandle[i];
  205.         if (i >= 0 && i <= 2) {
  206.             rch.d.top = rc.d.top - 2;
  207.             rch.d.bottom = rc.d.top + 2;
  208.         }
  209.         if (i >= 5 && i <= 7) {
  210.             rch.d.top = rc.d.bottom - 2;
  211.             rch.d.bottom = rc.d.bottom + 2;
  212.         }
  213.         if (i == 0 || i == 3 || i == 5) {
  214.             rch.d.left = rc.d.left - 2;
  215.             rch.d.right = rc.d.left + 2;
  216.         }
  217.         if (i == 2 || i == 4 || i == 7) {
  218.             rch.d.left = rc.d.right - 2;
  219.             rch.d.right = rc.d.right + 2;
  220.         }
  221.         if (i == 1 || i == 6) {
  222.             rch.d.left = rc.d.left + (rc.d.right - rc.d.left) / 2;
  223.             rch.d.right = rch.d.left + 2;
  224.             if (rc.d.right % 2 == 0)
  225.                 rch.d.left -= 2;
  226.         }
  227.         if (i == 3 || i == 4) {
  228.             rch.d.top = rc.d.top + (rc.d.bottom - rc.d.top) / 2;
  229.             rch.d.bottom = rch.d.top + 2;
  230.             if (rc.d.bottom % 2 == 0)
  231.                 rch.d.top -= 2;
  232.         }
  233.         pcv->rcHandle[i] = rch;
  234.     }
  235.  
  236.     /* ハンドルを描画する */
  237.     dispHdlRect(pcv, (*hcd)->id);
  238. }
  239.  
  240. /******************************************************************************
  241.  *    dispHdlRect():    カレント図形のハンドルを表示
  242.  ******************************************************************************
  243.  *    引数:    ComVal *pcv    共通変数へのポインタ
  244.  *        int type    処理している図形の種類
  245.  */
  246. void dispHdlRect(ComVal *pcv, int type)
  247. {
  248.     int i, max;
  249.     int savPenMode;
  250.  
  251.     if (pcv->actData == NULL)    /* アクティブ図形が存在しないか？ */
  252.         return;
  253.  
  254.     /* メインウィンドウをカレントグラフにする */
  255.     GMSetGraph(&pcv->windowPtr->graph);
  256.  
  257.     savPenMode = GMPenMode(G_XOR);    /* ペンモードをXORにする    */
  258.  
  259.     max = (type == 1) ? 2 : 8;
  260.  
  261.     for (i = 0; i < max; i++)
  262.         GMFillRect(&pcv->rcHandle[i]);
  263.     GMPenMode(savPenMode);        /* ペンモードを元に戻す        */
  264. }
  265.  
  266. /******************************************************************************
  267.  *    checkRectPos():    レクタングルの座標チェックおよび調整
  268.  ******************************************************************************
  269.  *    引数:    Rect *prc    レクタングルへのポインタ
  270.  *    注釈:
  271.  *    レクタングルの各座標をpt1がレクタングルの左上角に、pt2がレクタングルの
  272.  *    右下角の座標になるように調整を行う。
  273.  */
  274. void checkRectPos(Rect *prc)
  275. {
  276.     short save;
  277.  
  278.     /* topがbottomより大きいときは入れ換える */
  279.     if (prc->d.top > prc->d.bottom) {
  280.         save = prc->d.top;
  281.         prc->d.top = prc->d.bottom;
  282.         prc->d.bottom = save;
  283.     }
  284.     /* leftがrightより大きいときは入れ換える */
  285.     if (prc->d.left > prc->d.right) {
  286.         save = prc->d.left;
  287.         prc->d.left = prc->d.right;
  288.         prc->d.right = save;
  289.     }
  290. }
  291.  
  292. /******************************************************************************
  293.  *    checkPos():    指定座標が親ウィンドウの画面内にあるかを判断する処理
  294.  ******************************************************************************
  295.  *    引数:    ComVal *pcv    共通変数へのポインタ
  296.  *        Point *ppt    チェック座標（ローカル座標系）へのポインタ
  297.  *    注釈:
  298.  *    指定のチェック座標が親ウィンドウの画面から外れてるときは、画面内の最大
  299.  *    座標と置き換える。
  300.  */
  301. void checkPos(ComVal *pcv, Point *ppt)
  302. {
  303.     int calcF = 0;
  304.     BOOLEAN flag = FALSE, flag2 = FALSE;
  305.     double a, b;
  306.     Point calcP, calcP2;
  307.  
  308.     /* 処理図形が直線のとき */
  309.     if (pcv->drawType == 1 || pcv->drawType == 5) {
  310.         calcP = *ppt;
  311.         /* 座標が画面のどこを指しているのかをチェックする */
  312.         if (ppt->p.x < 0) {
  313.             /* 指定座標のＸ座標が負の値のとき */
  314.             calcP.p.x = 0;
  315.             flag = TRUE;
  316.         } else if (ppt->p.x > WIN_H) {
  317.             /* 指定座標のＸ座標が画面の右端より大きいとき */
  318.             calcP.p.x = WIN_H;
  319.             flag = TRUE;
  320.         }
  321.  
  322.         if (ppt->p.y < 0) {
  323.             /* 指定座標のＹ座標が負の値のとき */
  324.             calcP.p.y = 0;
  325.             flag2 = TRUE;
  326.         } else if (ppt->p.y > WIN_V) {
  327.             /* 指定座標のＹ座標が画面の底辺の値より大きいとき */
  328.             calcP.p.y = WIN_V;
  329.             flag2 = TRUE;
  330.         }
  331.  
  332.         if (flag)
  333.             /* Ｘ切片を計算するとき */
  334.             calcF += 1;
  335.         if (flag2)
  336.             /* Ｙ切片を計算するとき */
  337.             calcF += 2;
  338.         if (calcF == 3)
  339.             /* ＸＹ両切片を求めるときcalcPをcalcP2にも設定する */
  340.             calcP2 = calcP;
  341.  
  342.         if (calcF == 0)
  343.             /* 画面上に指定の座標は存在するので処理終了 */
  344.             return;
  345.  
  346.         if (pcv->downPos.p.x == calcP.p.x || pcv->downPos.p.y == calcP.p.y) {
  347.             /* 画面の境界に前回入力値が存在するとき */
  348.             *ppt = calcP;
  349.             return;
  350.         }
  351.  
  352.         if (pcv->downPos.p.x == ppt->p.x) {
  353.             /* 傾きがないとき */
  354.             ppt->p.y = calcP.p.y;
  355.             return;
  356.         }
  357.  
  358.         /* 方程式y = ax + bの要素aおよびbを求める */
  359.         a = (double)(pcv->downPos.p.y - ppt->p.y) / (double)(pcv->downPos.p.x - ppt->p.x);
  360.         b = (double) pcv->downPos.p.y - a * (double) pcv->downPos.p.x;
  361.  
  362.         /* calcFにより切片を求める */
  363.         if (calcF != 2)
  364.             /* Ｘ切片を求めるとき */
  365.             calcP.p.y = (short)(a * (double) calcP.p.x + b);
  366.         if (calcF != 1)
  367.             /* Ｙ切片を求めるとき */
  368.             calcP.p.x = (short)(((double) calcP.p.y - b) / a);
  369.         if (calcF == 3) {
  370.             /* ＸＹ両切片を求めるとき */
  371.             calcP2.p.x = (short)(((double) calcP2.p.y - b) / a);
  372.             if (!(calcP.p.x >= 0 && calcP.p.x <= WIN_H)
  373.              && !(calcP.p.y >= 0 && calcP.p.y <= WIN_H))
  374.                 /* 画面の内側に存在する座標をcalcPに設定する */
  375.                 calcP = calcP2;
  376.         }
  377.  
  378.         /* 算出した座標をpptに設定する */
  379.         *ppt = calcP;
  380.         return;
  381.  
  382.     } else {
  383.         /* 処理図形が 長方形,面取り長方形,楕円のとき */
  384.         if (ppt->p.x < 0)
  385.             /* 指定座標のＸ座標が負の値のとき */
  386.             ppt->p.x = 0;
  387.         else if (ppt->p.x > WIN_H)
  388.             /* 指定座標のＸ座標が画面の右端より大きいとき */
  389.             ppt->p.x = WIN_H;
  390.         if (ppt->p.y < 0)
  391.             /* 指定座標のＹ座標が負の値のとき */
  392.             ppt->p.y = 0;
  393.         else if (ppt->p.y > WIN_V)
  394.             /* 指定座標のＹ座標が画面の底辺の値より大きいとき */
  395.             ppt->p.y = WIN_V;
  396.     }
  397. }
  398.  
  399. /******************************************************************************
  400.  *    drawGraphRgn():    ウィンドウ内部の多角形の描画
  401.  ******************************************************************************
  402.  *    引数:    ComVal *pcv    共通変数へのポインタ
  403.  *    注釈:    drawTypeが多角形のときの処理を行う。
  404.  */
  405. void drawGraphRgn(ComVal *pcv)
  406. {
  407.     int cnt = pcv->rgnCnt;
  408.  
  409.     /* 多角形の座標入力点数が０のとき */
  410.     if (cnt == 0) {
  411.         /* 始点をセーブする */
  412.         pcv->rgnDPoint[cnt].x = (double) pcv->downPos.p.x;
  413.         pcv->rgnDPoint[cnt].y = (double) pcv->downPos.p.y;
  414.         /* ラバーバンド表示のために始点座標を設定する */
  415.         pcv->rbSize.l.l_t = pcv->downPos.x_y;
  416.  
  417.         /* カウントアップ */
  418.         pcv->rgnCnt++;
  419.     /* ダブルクリックされたとき */
  420.     } else if (pcv->animFlag == 2)
  421.  
  422.         /* 多角形の登録処理を行う */
  423.         makeRgn(pcv);
  424.  
  425.     else {
  426.         /* 入力された点を設定する */
  427.         pcv->rgnDPoint[cnt].x = (double) pcv->downPos.p.x;
  428.         pcv->rgnDPoint[cnt].y = (double) pcv->downPos.p.y;
  429.         pcv->rgnCnt++;
  430.  
  431.         /* 入力された部分の仮表示を行う */
  432.         pcv->rbSize.l.r_b = pcv->downPos.x_y;
  433.         pcv->dispRbFlag = TRUE;
  434.         dispRubberBand(pcv, 1);
  435.  
  436.         /* 次のラバーバンド表示のために始点座標を設定する */
  437.         pcv->rbSize.l.l_t = pcv->downPos.x_y;
  438.  
  439.         /* 入力可能な最終点のとき、ダブルクリックされたものと見なす */
  440.         if (cnt == 99) {
  441.             DMError(D_CONFIRM, "これ以上の点は入力できません。\r"
  442.                        "多角形を終了します。");
  443.             /* 多角形の登録処理を行う */
  444.             makeRgn(pcv);
  445.         }
  446.     }
  447. }
  448.  
  449. /******************************************************************************
  450.  *    makeRgn():    リージョン図形の登録および描画
  451.  ******************************************************************************
  452.  *    引数:    ComVal *pcv    共通変数へのポインタ
  453.  */
  454. void makeRgn(ComVal *pcv)
  455. {
  456.     int cnt, errCode;
  457.     short dx, dy;
  458.     LPoint lpt;
  459.     ComData **hcd;
  460.  
  461.     /* 多角形の仮表示の消去を行う */
  462.     dispRubberBand(pcv, 2);
  463.  
  464.     GMPenSize(pcv->penSize.x_y);    /* ペンサイズを設定する        */
  465.     GMForeColor(pcv->paletFC);
  466.  
  467.     /* データ登録用にメモリを確保する */
  468.     hcd = MMChHdlNew(sizeof(ComData));
  469.     if (hcd == NULL) {
  470.         DMError(D_CONFIRM, "メモリが不足しています。\r"
  471.                    "データの登録ができません。");
  472.         return;
  473.     }
  474.  
  475.     /* 空のリージョンを作成する */
  476.     (*hcd)->ext.rgn.hdl = GMNewRgn();
  477.     if ((*hcd)->ext.rgn.hdl == NULL) {
  478.         DMError(D_CONFIRM, "メモリが確保できません。");
  479.         return;
  480.     }
  481.     /* リージョンの記録開始 */
  482.     GMOpenRgn();
  483.     /* 多角形の描画 */
  484.     /* 表示位置をデータの先頭に設定する */
  485.     lpt = LONGWORD(pcv->rgnDPoint[0].x, pcv->rgnDPoint[0].y);
  486.     GMMove(lpt);
  487.     /* データを元に描画を行う */
  488.     for (cnt = 1; cnt < pcv->rgnCnt; cnt++)
  489.         GMLine(LONGWORD(pcv->rgnDPoint[cnt].x, pcv->rgnDPoint[cnt].y));
  490.     /* 始点データと結ぶ */
  491.     GMLine(lpt);
  492.     /* リージョンの記録終了 */
  493.     errCode = GMCloseRgn((*hcd)->ext.rgn.hdl);
  494.     if (errCode < 0) {
  495.         DMError(D_CONFIRM, "メモリが不足しています。\r"
  496.                    "リージョンの記録ができません。");
  497.         return;
  498.     }
  499.  
  500.     /* 多角形を囲むレクタングルの座標をcomDataのboundsに設定する */
  501.     (*hcd)->bounds = (*(*hcd)->ext.rgn.hdl)->bounds;
  502.     /* 多角形の点数を設定 */
  503.     (*hcd)->ext.rgn.cnt = pcv->rgnCnt;
  504.     /* リージョンデータを設定する */
  505.     memcpy((*hcd)->ext.rgn.dPoint, pcv->rgnDPoint, sizeof(DPoint) * MAX_RGN_CNT);
  506.     /* boundsの左上座標からの相対座標に変換する */
  507.     dx = (*hcd)->bounds.d.left;
  508.     dy = (*hcd)->bounds.d.top;
  509.     for (cnt = 0; cnt < pcv->rgnCnt; cnt++) {
  510.         (*hcd)->ext.rgn.dPoint[cnt].x -= dx;
  511.         (*hcd)->ext.rgn.dPoint[cnt].y -= dy;
  512.     }
  513.  
  514.     /* 共通データの登録処理 */
  515.     setComData(pcv, hcd);
  516. }
  517.  
  518. /******************************************************************************
  519.  *    dispRubberBand():    ラバーバンド表示処理
  520.  ******************************************************************************
  521.  *    引数:    ComVal *pcv    共通変数へのポインタ
  522.  *        int mode    描画方法
  523.  *                = 0: 通常のラバーバンド表示
  524.  *                = 1: ラバーバンド表示の消去のみ
  525.  *                = 2: リージョンの仮表示消去
  526.  *    注釈:    処理図形のラバーバンド表示を行う。
  527.  */
  528. void dispRubberBand(ComVal *pcv, int mode)
  529. {
  530.     int cnt, type;
  531.     int disp;
  532.     int savPenMode;
  533.     Point pt;
  534.     Rect savRect;
  535.  
  536.     /* 処理対象外 */
  537.     if (mode == 0) {
  538.         if (pcv->drawType == 5) {
  539.             if (pcv->rgnCnt == 0)
  540.                 return;
  541.  
  542.         } else if (pcv->animFlag != 1 || !EMLStill())
  543.             return;
  544.     }
  545.  
  546.     /* 選択処理のとき */
  547.     if (pcv->drawType == 8) {
  548.         /* 現在選択されているデータが存在しないとき、または
  549.            図形選択モードのときは、何もせずに終了 */
  550.         if (pcv->actData == NULL || pcv->selMode == -1)
  551.             return;
  552.  
  553.         /* ペンサイズを設定する */
  554.         GMPenSize((*pcv->actData)->penSize.x_y);
  555.     } else
  556.         GMPenSize(pcv->penSize.x_y); /* ペンサイズを設定する    */
  557.  
  558.     GMForeColor(G_BLACK);        /* フォアグラウンドカラーを黒にする */
  559.     savPenMode = GMPenMode(G_XOR);    /* ペンモードをXORにする    */
  560.  
  561.     /* 通常のラバーバンド処理のとき */
  562.     if (mode == 0) {
  563.         /* マウスポインタの位置を取得する */
  564.         pt.x_y = EMMSLoc();
  565.         /* 取得座標が画面を外れてないかチェックする */
  566.         checkPos(pcv, &pt);
  567.  
  568.         /* 前回の位置と変わってるとき */
  569.         if (!(pcv->dispRbFlag && pt.p.x == pcv->rbPos.p.x && pt.p.y == pcv->rbPos.p.y)) {
  570.             /* 画面上にラバーバンド表示がある場合は消去する */
  571.             if (pcv->dispRbFlag) {
  572.                 /* drawZukeiの第２パラメータを設定する */
  573.                 disp = pcv->drawType;
  574.                 if (disp == 8) {
  575.                     disp = (*pcv->actData)->id;
  576.                     if (disp == 5)
  577.                         disp = 9;
  578.                 }
  579.                 /* 表示されているラバーバンドの消去 */
  580.                 drawZukei(pcv, disp, 0, &pcv->rbSize);
  581.  
  582.                 /* ラバーバンド表示フラグをFALSEにする */
  583.                 pcv->dispRbFlag = FALSE;
  584.             }
  585.             /* rbSizeのデータをセーブする */
  586.             savRect = pcv->rbSize;
  587.             /* ラバーバンド座標の設定を行う */
  588.             type = setRBRect(pcv, pt.x_y);
  589.             /* 多角形のとき */
  590.             if (type == 0) {
  591.                 if (pcv->drawType == 8) {
  592.                     /* 拡大／縮小処理のとき */
  593.                     if (pcv->selMode > 0) {
  594.                         if (!GMEmptyRect(&pcv->rbSize)) {
  595.                             /* 拡大／縮小後の多角形
  596.                                の各点を求める */
  597.                             double dx, dy, sx, sy, a, b;
  598.  
  599.                             sx = (double)(savRect.d.right - savRect.d.left);
  600.                             sy = (double)(savRect.d.bottom - savRect.d.top);
  601.                             dx = (double)(pcv->rbSize.d.right - pcv->rbSize.d.left);
  602.                             dy = (double)(pcv->rbSize.d.bottom - pcv->rbSize.d.top);
  603.                             for (cnt = 0; cnt < pcv->rgnCnt; cnt++) {
  604.                                 a = pcv->rgnDPoint[cnt].x;
  605.                                 b = pcv->rgnDPoint[cnt].y;
  606.                                 pcv->rgnDPoint[cnt].x = dx * a / sx;
  607.                                 pcv->rgnDPoint[cnt].y = dy * b / sy;
  608.                             }
  609.                         } else
  610.                             /* rbSizeのデータを元に戻す */
  611.                             pcv->rbSize = savRect;
  612.                     }
  613.                     disp = 9;
  614.                 } else
  615.                     disp = 5;
  616.                 /* ラバーバンドの表示を行う */
  617.                 drawZukei(pcv, disp, 0, &pcv->rbSize);
  618.                 /* ラバーバンド表示フラグをTRUEにする */
  619.                 pcv->dispRbFlag = TRUE;
  620.             } else if (type > 0) {
  621.                 /* ラバーバンドの表示を行う */
  622.                 drawZukei(pcv, type, 0, &pcv->rbSize);
  623.                 /* ラバーバンド表示フラグをTRUEにする */
  624.                 pcv->dispRbFlag = TRUE;
  625.             }
  626.             /* 入力点を格納しておく */
  627.             pcv->rbPos = pt;
  628.         }
  629.     /* ラバーバンド消去のとき */
  630.     } else if (mode == 1) {
  631.         if (pcv->dispRbFlag) {
  632.             /* drawZukeiの第２パラメータを設定する */
  633.             disp = pcv->drawType;
  634.             if (disp == 8) {
  635.                 disp = (*pcv->actData)->id;
  636.                 if (disp == 5)
  637.                     disp = 9;
  638.             }
  639.             /* 表示されているラバーバンドの消去 */
  640.             drawZukei(pcv, disp, 0, &pcv->rbSize);
  641.  
  642.             /* ラバーバンド表示フラグをFALSEにする */
  643.             pcv->dispRbFlag = FALSE;
  644.         }
  645.     /* 多角形の仮表示消去のとき */
  646.     } else {
  647.         /* 表示位置をデータの先頭に設定する */
  648.         GMMove(LONGWORD(pcv->rgnDPoint[0].x, pcv->rgnDPoint[0].y));
  649.         /* 格納データを元に仮表示を消去する */
  650.         for (cnt = 1; cnt < pcv->rgnCnt; cnt++)
  651.             GMLine(LONGWORD(pcv->rgnDPoint[cnt].x, pcv->rgnDPoint[cnt].y));
  652.     }
  653.  
  654.     /* ペンモードを元に戻す */
  655.     GMPenMode(savPenMode);
  656.     /* 描画色を現在の描画色に設定 */
  657.     GMForeColor(pcv->paletFC);
  658.     /* ペンサイズを現在の描画色に設定 */
  659.     GMPenSize(pcv->penSize.x_y);
  660. }
  661.  
  662. /******************************************************************************
  663.  *    drawZukei():    実際の図形表示処理
  664.  ******************************************************************************
  665.  *    引数:    ComVal *pcv    共通変数へのポインタ
  666.  *        int type    描画図形の種類
  667.  *        int mode    描画モード
  668.                 = 0: 枠
  669.  *                = 1: 塗りつぶし
  670.  *        Rect *prc    表示に使用する座標へのポインタ
  671.  *    注釈:    指定の図形を指定の座標を用いて表示する。
  672.  */
  673. void drawZukei(ComVal *pcv, int type, int mode, Rect *prc)
  674. {
  675.     int stat;
  676.     Rect rc;
  677.     ComData **hcd;
  678.  
  679.     switch (type) {
  680.     case 1:
  681.     case 5:
  682.         /* 直線の描画を行う */
  683.         GMMove(prc->l.l_t);
  684.         GMLine(prc->l.r_b);
  685.         break;
  686.     case 2:                /* 長方形        */
  687.     case 3:                /* 楕円            */
  688.     case 4:                /* 面取り長方形        */
  689.         /* prcのデータをrcにコピーする */
  690.         rc = *prc;
  691.         /* レクタングルの座標をチェックする */
  692.         checkRectPos(&rc);
  693.         if (!GMEmptyRect(&rc)) {
  694.             /* null Rectではないとき */
  695.             switch (type) {
  696.             case 2:
  697.                 /* 長方形の描画を行う */
  698.                 if (mode == 0)
  699.                     /* 描画モードが枠のとき */
  700.                     GMFrameRect(&rc);
  701.                 else
  702.                     /* 描画モードが塗りつぶしのとき */
  703.                     GMFillRect(&rc);
  704.                 break;
  705.             case 3:
  706.                 /* 楕円の描画を行う */
  707.                 if (mode == 0)
  708.                     /* 描画モードが枠のとき */
  709.                     GMFrameOval(&rc);
  710.                 else
  711.                     /* 描画モードが塗りつぶしのとき */
  712.                     GMFillOval(&rc);
  713.                 break;
  714.             default:
  715.                 /* 面取り長方形の描画を行う */
  716.                 if (mode == 0)
  717.                     /* 描画モードが枠のとき */
  718.                     GMFrameRRect(&rc, pcv->radius.x_y);
  719.                 else
  720.                     /* 描画モードが塗りつぶしのとき */
  721.                     GMFillRRect(&rc, pcv->radius.x_y);
  722.                 break;
  723.             }
  724.         } else {
  725.             /* null Rectのとき */
  726.             if (rc.d.right - rc.d.left > rc.d.bottom - rc.d.top) {
  727.                 rc.d.bottom = rc.d.top;
  728.                 GMMove(rc.l.l_t);
  729.                 GMLine(rc.l.r_b);
  730.             } else {
  731.                 rc.d.right = rc.d.left;
  732.                 GMMove(rc.l.l_t);
  733.                 GMLine(rc.l.r_b);
  734.             }
  735.         }
  736.         break;
  737.     case 8:                /* 多角形表示処理    */
  738.         hcd = pcv->actData;
  739.         if ((*hcd)->ext.rgn.hdl == NULL)
  740.             break;
  741.         stat = GMEmptyRgn((*hcd)->ext.rgn.hdl);
  742.         if (stat == 1) {    /* ヌル・リージョンのとき */
  743.             rc = (*hcd)->bounds;
  744.             if (rc.d.right - rc.d.left > rc.d.bottom - rc.d.top) {
  745.                 rc.d.bottom = rc.d.top;
  746.                 GMMove(rc.l.l_t);
  747.                 GMLine(rc.l.r_b);
  748.             } else {
  749.                 rc.d.right = rc.d.left;
  750.                 GMMove(rc.l.l_t);
  751.                 GMLine(rc.l.r_b);
  752.             }
  753.             (*hcd)->bounds = rc;
  754.             break;
  755.         }
  756.         if (mode == 0)
  757.             GMFrameRgn((*hcd)->ext.rgn.hdl);
  758.         else
  759.             GMFillRgn((*hcd)->ext.rgn.hdl);
  760.         break;
  761.     case 9:                /* 多角形ラバーバンド表示処理    */
  762.         dispRBRgn(pcv, 1);
  763.         break;
  764.     }
  765. }
  766.  
  767. /******************************************************************************
  768.  *    dispRBRgn():    多角形ラバーバンド表示処理
  769.  ******************************************************************************
  770.  *    引数:    ComVal *pcv    共通変数へのポインタ
  771.  *        BOOLEAN type    始点と終点の関係
  772.                 = 0: ２点を結ばない
  773.  *                = 1: ２点を結ぶ
  774.  */
  775. void dispRBRgn(ComVal *pcv, BOOLEAN type)
  776. {
  777.     int cnt;
  778.     Point pt;
  779.  
  780.     /* rgnDPoint に格納してあるデータを元に region の仮表示を行う。
  781.        このとき格納してあるデータは１０倍されているので１０分の１にしてから
  782.        座標として扱う */
  783.     pt.p.x = pcv->rgnDPoint[0].x + pcv->rbSize.d.left;
  784.     pt.p.y = pcv->rgnDPoint[0].y + pcv->rbSize.d.top;
  785.     GMMove(pt.x_y);
  786.     for (cnt = 1; cnt < pcv->rgnCnt; cnt++)
  787.         GMLine(LONGWORD((short) pcv->rgnDPoint[cnt].x + pcv->rbSize.d.left, (short) pcv->rgnDPoint[cnt].y + pcv->rbSize.d.top));
  788.     if (type == 1)
  789.         /* 最終点と始点を結ぶ */
  790.         GMLine(pt.x_y);
  791. }
  792.  
  793. /******************************************************************************
  794.  *    selectZukei():    選択処理中のマウスレフトダウンイベント処理
  795.  ******************************************************************************
  796.  *    引数:    ComVal *pcv    共通変数へのポインタ
  797.  *        LPoint lpt    マウス位置
  798.  */
  799. void selectZukei(ComVal *pcv, LPoint lpt)
  800. {
  801.     int num;
  802.     ComData **hcd = pcv->actData;
  803.  
  804.     /* メインウィンドウをカレントグラフにする */
  805.     GMSetGraph(&pcv->windowPtr->graph);
  806.  
  807.     /* 入力座標がアクティブ図形のハンドルを指しているかの、チェックを行う */
  808.     num = checkHdl(pcv, lpt);
  809.     if (num != 0) {
  810.         /* ハンドルを指しているとき、モードを拡大／縮小処理に設定 */
  811.         pcv->selMode = num;
  812.         /* ラバーバンドに必要な情報の設定 */
  813.         pcv->rbSize = (*hcd)->bounds;
  814.         /* 多角形のときは必要なデータをコピーする */
  815.         if ((*hcd)->id == 5) {
  816.             /* 多角形データをコピーする */
  817.             memcpy(pcv->rgnDPoint, (*hcd)->ext.rgn.dPoint, sizeof(DPoint) * MAX_RGN_CNT);
  818.             /* 多角形の角数をコピーする */
  819.             pcv->rgnCnt = (*hcd)->ext.rgn.cnt;
  820.         }
  821.         /* 表示されているハンドルを消去する */
  822.         if (pcv->actData != NULL)
  823.             dispHdlRect(pcv, (*hcd)->id);
  824.  
  825.         /* 現在の選択図形を画面上から消去する */
  826.         eraseData(pcv);
  827.  
  828.         pcv->rbPos.x_y = lpt;
  829.         return;
  830.     }
  831.     /* アクティブ図形を指しているとき */
  832.     if (checkZukei(hcd, lpt)) {
  833.         /* モードを移動に設定 */
  834.         pcv->selMode = 0;
  835.         /* ラバーバンドに必要な情報の設定 */
  836.         pcv->downPos.x_y = lpt;
  837.         pcv->rbSize = (*hcd)->bounds;
  838.  
  839.         /* 多角形のときは必要なデータをコピーする */
  840.         if ((*hcd)->id == 5) {
  841.             /* 多角形データをコピーする */
  842.             memcpy(pcv->rgnDPoint, (*hcd)->ext.rgn.dPoint, sizeof(DPoint) * MAX_RGN_CNT);
  843.             /* 多角形の角数をコピーする */
  844.             pcv->rgnCnt = (*hcd)->ext.rgn.cnt;
  845.         }
  846.  
  847.         /* 表示されているハンドルを消去する */
  848.         if (pcv->actData != NULL)
  849.             dispHdlRect(pcv, (*hcd)->id);
  850.  
  851.         /* 現在の選択図形を画面上から消去する */
  852.         eraseData(pcv);
  853.  
  854.         pcv->rbPos.x_y = lpt;
  855.         return;
  856.     }
  857.     /* どの図形を指しているのかをチェックする */
  858.     /* hcdに現在の一番上のデータのハンドルを設定する */
  859.     hcd = pcv->data;
  860.     while (hcd != NULL) {
  861.         /* hcdの図形を指しているときはLOOPを抜ける */
  862.         if (checkZukei(hcd, lpt))
  863.             break;
  864.         /* hcdに更に１つ前のデータのハンドルを設定する */
  865.         hcd = (*hcd)->next;
  866.     }
  867.     /* pcv->actData に hcd を設定する。どの図形も指していないときは、
  868.        アクティブ図形なしとなり NULL が設定される */
  869.     if (pcv->actData != hcd) {
  870.         /* 表示されているハンドルを消去する */
  871.         if (pcv->actData != NULL)
  872.             dispHdlRect(pcv, (*pcv->actData)->id);
  873.  
  874.         /* アクティブ図形を設定する */
  875.         pcv->actData = hcd;
  876.  
  877.         /* アクティブ図形にハンドルを表示する */
  878.         if (pcv->actData != NULL)
  879.             dispCurHdl(pcv);
  880.     }
  881.  
  882.     /* モードを選択に設定 */
  883.     pcv->selMode = -1;
  884.  
  885.     pcv->rbPos.x_y = lpt;
  886. }
  887.  
  888. /******************************************************************************
  889.  *    checkHdl():    ハンドルをクリックしたかのチェック
  890.  ******************************************************************************
  891.  *    引数:    ComVal *pcv    共通変数へのポインタ
  892.  *        LPoint lpt    マウス位置
  893.  *    戻り値:    int pos        ハンドル位置
  894.  *                = 1～8: 下図参照
  895.  *                = 0:    ハンドル以外の場所をクリック
  896.  *    注釈:    ハンドルの位置は以下のとおりです。
  897.  *             長方形          直線
  898.  *            1    2    3    1
  899.  *        +-------+-------+    +
  900.  *        |        |    |
  901.  *          4 +        + 5    |
  902.  *        |        |    |
  903.  *        +-------+-------+    +
  904.  *        6    7    8    2
  905.  */
  906. int checkHdl(ComVal *pcv, LPoint lpt)
  907. {
  908.     int pos = 0;
  909.     int i, max;
  910.  
  911.     /* アクティブな図形が存在しないときは、処理を終了する */
  912.     if (pcv->actData == NULL)
  913.         return 0;
  914.  
  915.     /* max値の設定（データが直線／直線以外のとき）*/
  916.     max = ((*pcv->actData)->id == 1) ? 2 : 8;
  917.  
  918.     /* ハンドル内をクリックされたかを順にチェックする */
  919.     for (i = 0; i < max; i++) {
  920.         /* ハンドル内と判断されるとき */
  921.         if (GMPtInRect(&pcv->rcHandle[i], lpt)) {
  922.             /* pos にハンドル位置を設定する */
  923.             pos = i + 1;
  924.             break;
  925.         }
  926.         pos = 0;
  927.     }
  928.  
  929.     return pos;
  930. }
  931.  
  932. /******************************************************************************
  933.  *    checkZukei():    指定の図形を選択しているかどうかのチェック
  934.  ******************************************************************************
  935.  *    引数:    ComData    **hcd    図形データのハンドル
  936.  *        LPoint lpt    マウス位置
  937.  *    戻り値:    BOOLEAN ret    = TRUE:  図形の内側
  938.  *                = FALSE: 図形の外側
  939.  */
  940. BOOLEAN checkZukei(ComData **hcd, LPoint lpt)
  941. {
  942.     BOOLEAN ret = FALSE;
  943.  
  944.     if (hcd == NULL)
  945.         return FALSE;
  946.  
  947.     switch ((*hcd)->id) {
  948.     case 1:                /* 直線            */
  949.         ret = checkLine(&(*hcd)->bounds, lpt, &(*hcd)->penSize);
  950.         break;
  951.     case 2:                /* 長方形        */
  952.     case 3:                /* 楕円            */
  953.     case 4:                /* 面取り長方形        */
  954.     case 5:                /* 多角形        */
  955.         /* 図形を囲むレクタングル内を選択されたとき */
  956.         if (GMPtInRect(&(*hcd)->bounds, lpt))
  957.             ret = TRUE;
  958.         break;
  959.     }
  960.  
  961.     return ret;
  962. }
  963.  
  964. /******************************************************************************
  965.  *    checkLine():    指定の点が指定の線上にあるかどうかの判断
  966.  ******************************************************************************
  967.  *    引数:    Rect *prc    線のデータ
  968.  *        LPoint lpt    マウス位置
  969.  *        Point *pps    ペンサイズへのポインタ
  970.  *    戻り値:    BOOLEAN        = TRUE:  線上の点である
  971.  *                = FALSE: 線上にはない
  972.  */
  973. BOOLEAN checkLine(Rect *prc, LPoint lpt, Point *pps)
  974. {
  975.     double a, b, d1 = -1, d2 = -1;
  976.     Point pt, pt1, pt2, dpt;
  977.     Rect rc;
  978.  
  979.     pt.x_y = lpt;
  980.     pt1.x_y = prc->l.l_t;
  981.     pt2.x_y = prc->l.r_b;
  982.     rc = *prc;
  983.     checkRectPos(&rc);    /* レクタングルを整える */
  984.  
  985.     dpt.p.x = pt1.p.x - pt2.p.x;
  986.     dpt.p.y = pt1.p.y - pt2.p.y;
  987.     if (dpt.p.x && dpt.p.y) {
  988.         /* 斜めの直線の場合 */
  989.         if (pt.p.x < rc.d.left || pt.p.x > rc.d.right)
  990.             /* マウス位置が直線の範囲外 */
  991.             return FALSE;
  992.         /* 方程式 y = ax + bの要素 aおよびb を求める */
  993.         a = (double) dpt.p.y / (double) dpt.p.x;
  994.         b = (double) pt1.p.y - a * (double) pt1.p.x;
  995.         d1 = (double) pt.p.x - ((double) pt.p.y - b) / a + 2;
  996.         d2 = (double) pt.p.y - (a * (double) pt.p.x + b) + 2;
  997.     } else if (dpt.p.x && !dpt.p.y) {
  998.         /* 水平な直線の場合 */
  999.         if (pt.p.x < rc.d.left || pt.p.x > rc.d.right)
  1000.             /* マウス位置が直線の範囲外 */
  1001.             return FALSE;
  1002.         d1 = (double) pt.p.y - (double) pt1.p.y + 2;
  1003.         d2 = -1;
  1004.     } else if (!dpt.p.x && dpt.p.y) {
  1005.         /* 垂直な直線の場合 */
  1006.         if (pt.p.y < rc.d.top || pt.p.y > rc.d.bottom)
  1007.             /* マウス位置が直線の範囲外 */
  1008.             return FALSE;
  1009.         d1 = (double) pt.p.x - (double) pt1.p.x + 2;
  1010.         d2 = -1;
  1011.     }
  1012.     return ((d1 >= 0 && d1 <= pps->p.x + 4)
  1013.         || (d2 >= 0 && d2 <= pps->p.y + 4));
  1014. }
  1015.  
  1016. /******************************************************************************
  1017.  *    setRBRect():    選択処理中のラバーバンドのレクタングル設定処理
  1018.  ******************************************************************************
  1019.  *    引数:    ComVal *pcv    共通変数へのポインタ
  1020.  *        LPoint lpt    マウス位置
  1021.  *    戻り値:    int type    1－5: 処理図形の種類
  1022.  *                0:    リージョンのとき
  1023.  *                -1:   対象外
  1024.  */
  1025. int setRBRect(ComVal *pcv, LPoint lpt)
  1026. {
  1027.     int type, mode;
  1028.     Point pt, dpt;
  1029.     ComData **hcd = pcv->actData;    /* 選択図形の共通データのハンドル */
  1030.  
  1031.     /* 処理が選択のとき */
  1032.     if (pcv->drawType == 8) {
  1033.         /* modeに処理モードを設定する */
  1034.         mode = pcv->selMode;
  1035.         pt.x_y = lpt;
  1036.         /* 移動モードのとき */
  1037.         if (mode == 0) {
  1038.             /* 移動量を求める */
  1039.             dpt.p.x = pt.p.x - pcv->downPos.p.x;
  1040.             dpt.p.y = pt.p.y - pcv->downPos.p.y;
  1041.             /* 移動後のレクタングルを求める */
  1042.             pcv->rbSize.d.left   += dpt.p.x;
  1043.             pcv->rbSize.d.right  += dpt.p.x;
  1044.             pcv->rbSize.d.top    += dpt.p.y;
  1045.             pcv->rbSize.d.bottom += dpt.p.y;
  1046.  
  1047.             pcv->downPos = pt;
  1048.             type = (*hcd)->id;
  1049.             if (type == 5)
  1050.                 /* 処理図形が多角形のとき０を設定 */
  1051.                 type = 0;
  1052.         } else if (mode > 0) {    /* 拡大／縮小モードのとき */
  1053.             /* 選択図形が 直線 のとき */
  1054.             if ((*hcd)->id == 1) {
  1055.                 /* rbSizeの変更を行う */
  1056.                 if (mode == 1)
  1057.                     pcv->rbSize.l.l_t = lpt;
  1058.                 else
  1059.                     pcv->rbSize.l.r_b = lpt;
  1060.             } else {    /* 選択図形が 直線 以外のとき */
  1061.                 /* rbSizeの設定 */
  1062.                 pcv->rbSize = (*hcd)->bounds;
  1063.                 /* rbSizeの left 座標に変更が必要なとき */
  1064.                 if (mode == 1 || mode == 4 || mode == 6)
  1065.                     pcv->rbSize.d.left = pt.p.x;
  1066.                 /* rbSizeの top 座標に変更が必要なとき */
  1067.                 if (mode == 1 || mode == 2 || mode == 3)
  1068.                     pcv->rbSize.d.top = pt.p.y;
  1069.                 /* rbSizeの right 座標に変更が必要なとき */
  1070.                 if (mode == 3 || mode == 5 || mode == 8)
  1071.                     pcv->rbSize.d.right = pt.p.x;
  1072.                 /* rbSizeの bottom 座標に変更が必要なとき */
  1073.                 if (mode == 6 || mode == 7 || mode == 8)
  1074.                     pcv->rbSize.d.bottom = pt.p.y;
  1075.                 checkRectPos(&pcv->rbSize);
  1076.             }
  1077.             /* 戻り値の設定 */
  1078.             type = (*hcd)->id;
  1079.             if (type == 5)
  1080.                 type = 0;
  1081.         } else
  1082.             type = -1;
  1083.     /* 図形入力処理中 */
  1084.     } else {
  1085.         /* ラバーバンド座標の設定を行う */
  1086.         pcv->rbSize.l.r_b = lpt;
  1087.         type = pcv->drawType;
  1088.     }
  1089.  
  1090.     return type;
  1091. }
  1092.  
  1093. /******************************************************************************
  1094.  *    decisionZukei():    マウスレフトアップイベント時の図形確定処理
  1095.  ******************************************************************************
  1096.  *    引数:    ComVal *pcv    共通変数へのポインタ
  1097.  */
  1098. void decisionZukei(ComVal *pcv)
  1099. {
  1100.     int type, errCode = 0;
  1101.     Point pt;
  1102.     Rect rc;
  1103.     ComData **hcd;
  1104.  
  1105.     /* メインウィンドウをカレントグラフにする */
  1106.     GMSetGraph(&pcv->windowPtr->graph);
  1107.  
  1108.     /* 入力座標値をグローバルからローカルに変換する */
  1109.     pt.x_y = GMGlobalToLocal(pcv->event.ev.where.x_y);
  1110.     /* 座標が画面を外れてないかチェックする */
  1111.     checkPos(pcv, &pt);
  1112.     /* 入力座標をupPosに設定 */
  1113.     pcv->upPos = pt;
  1114.  
  1115.     /* 処理が選択以外のとき */
  1116.     if (pcv->drawType != 8) {
  1117.         /* animFlagを描画に設定 */
  1118.         pcv->animFlag = 2;
  1119.         /* 描画処理を行う */
  1120.         drawGraph(pcv);
  1121.     }
  1122.  
  1123.     /* 処理が選択のとき */
  1124.     /* animFlagをクリアする */
  1125.     pcv->animFlag = 0;
  1126.     /* ただの選択処理のときは、何もせずに終了する */
  1127.     if (pcv->selMode == -1)
  1128.         return;
  1129.  
  1130.     /* 画面上にラバーバンド表示がある場合は消去する */
  1131.     if (pcv->dispRbFlag)
  1132.         dispRubberBand(pcv, 1);
  1133.     /* rbSize data save */
  1134.     rc = pcv->rbSize;
  1135.  
  1136.     /* ラバーバンド座標の設定を行うことにより確定座標の決定を行う */
  1137.     type = setRBRect(pcv, pt.x_y);
  1138.     if (type == 0) {
  1139.         /* 図形データの共通データのハンドルを hcd に取得する */
  1140.         hcd = pcv->actData;
  1141.  
  1142.         /* ヌルレクタングルかどうかをチェックする */
  1143.         if (!GMEmptyRect(&pcv->rbSize)) {
  1144.             /* ヌルレクタングルではないとき */
  1145.             if (pcv->selMode > 0) {
  1146.                 /* 拡大／縮小処理のとき */
  1147.                 int cnt;
  1148.                 double dx, dy, sx, sy;
  1149.  
  1150.                 /* 拡大／縮小後の多角形の各点を求める */
  1151.                 sx = (double)(rc.d.right - rc.d.left);
  1152.                 sy = (double)(rc.d.bottom - rc.d.top);
  1153.                 dx = (double)(pcv->rbSize.d.right - pcv->rbSize.d.left);
  1154.                 dy = (double)(pcv->rbSize.d.bottom - pcv->rbSize.d.top);
  1155.  
  1156.                 for (cnt = 0; cnt < pcv->rgnCnt; cnt++) {
  1157.                     pcv->rgnDPoint[cnt].x = dx * pcv->rgnDPoint[cnt].x / sx;
  1158.                     pcv->rgnDPoint[cnt].y = dy * pcv->rgnDPoint[cnt].y / sy;
  1159.                 }
  1160.  
  1161.             }
  1162.             if ((*hcd)->ext.rgn.hdl != NULL) {
  1163.                 /* 多角形のリージョンを作成し直す */
  1164.                 GMOpenRgn();
  1165.                 dispRBRgn(pcv, 1);
  1166.                 errCode = GMCloseRgn((*hcd)->ext.rgn.hdl);
  1167.             }
  1168.             if ((*hcd)->ext.rgn.hdl == NULL || errCode < 0) {
  1169.                 DMError(D_CONFIRM, "メモリが不足しています。\r"
  1170.                            "リージョンの記録ができません。");
  1171.                 return;
  1172.             }
  1173.             /* 共通データのboundsを再設定する */
  1174.             (*hcd)->bounds = pcv->rbSize;
  1175.             /* リージョンデータをコピーする */
  1176.             memcpy((*hcd)->ext.rgn.dPoint, pcv->rgnDPoint, sizeof(DPoint) * MAX_RGN_CNT);
  1177.         } else
  1178.             /* rbSizeデータを元に戻す */
  1179.             pcv->rbSize = rc;
  1180.  
  1181.         /* 描画ペンサイズの設定 */
  1182.         GMPenSize((*pcv->actData)->penSize.x_y);
  1183.         /* 確定図形の表示を行う */
  1184.         drawZukei(pcv, 8, (*hcd)->drawMode, &pcv->rbSize);
  1185.         GMPenSize(pcv->penSize.x_y); /* ペンサイズを設定する    */
  1186.         /* 多角形の角数をセーブする */
  1187.         pcv->rgnCnt = 0;
  1188.  
  1189.     } else if (type > 0) {
  1190.         /* null Rect でかどうかをチェックする */
  1191.         if (type == 1 || !GMEmptyRect(&pcv->rbSize))
  1192.             /* null Rectではないとき、または直線のとき、
  1193.                共通データのboundsを再設定する */
  1194.             (*pcv->actData)->bounds = pcv->rbSize;
  1195.         else
  1196.             /* rbSizeデータを元に戻す */
  1197.             pcv->rbSize = (*pcv->actData)->bounds;
  1198.         /* 描画ペンサイズの設定 */
  1199.         GMPenSize((*pcv->actData)->penSize.x_y);
  1200.         /* 確定図形の表示を行う */
  1201.         drawZukei(pcv, type, (*pcv->actData)->drawMode, &pcv->rbSize);
  1202.         GMPenSize(pcv->penSize.x_y); /* ペンサイズを設定する    */
  1203.     }
  1204.  
  1205.     /* 選択されているデータのハンドルを表示する */
  1206.     dispCurHdl(pcv);
  1207.     pcv->selMode = -1;
  1208. }
  1209.  
  1210. /******************************************************************************
  1211.  *    deleteData():    現在指定されている図形の削除
  1212.  ******************************************************************************
  1213.  *    引数:    ComVal *pcv    共通変数へのポインタ
  1214.  */
  1215. void deleteData(ComVal *pcv)
  1216. {
  1217.     int savType;
  1218.     Point pt;
  1219.     Rect rc;
  1220.     ComData **hcd, **temp1, **temp2;
  1221.  
  1222.     if (pcv->actData == NULL)
  1223.         return;
  1224.  
  1225.     /* 現在登録されている最後のデータのハンドル */
  1226.     hcd = pcv->data;
  1227.     /* 現在選択されているデータのハンドル */
  1228.     temp1 = pcv->actData;
  1229.     /* 現在選択されているデータの１つ前のデータのハンドル */
  1230.     temp2 = (*temp1)->next;
  1231.  
  1232.     /* 最後に登録された図形と現在選択されている図形が同じとき */
  1233.     if (hcd == temp1)
  1234.         pcv->data = temp2;
  1235.     else {
  1236.         /* hcdから順にデータをたどっていってnextにtemp1が格納されている
  1237.            ところを捜し出し、temp2を設定する */
  1238.         while (hcd != NULL) {
  1239.             if ((*hcd)->next == temp1) {
  1240.                 (*hcd)->next = temp2;
  1241.                 break;
  1242.             }
  1243.             hcd = (*hcd)->next;
  1244.         }
  1245.     }
  1246.     /* 削除するデータを囲むレクタングルをセーブする */
  1247.     rc = (*temp1)->bounds;
  1248.  
  1249.     /* 図形の種類とペンサイズをセーブしておく */
  1250.     savType = (*temp1)->id;
  1251.     pt = (*temp1)->penSize;
  1252.  
  1253.     if ((*temp1)->id == 1)
  1254.         checkRectPos(&rc);
  1255.  
  1256.     /* ハンドルを消去する */
  1257.     dispHdlRect(pcv, (*pcv->actData)->id);
  1258.  
  1259.     /* データカウンタをマイナスする */
  1260.     pcv->dataCnt--;
  1261.  
  1262.     if ((*temp1)->id == 5 && (*temp1)->ext.rgn.hdl != NULL)
  1263.         /* 処理図形が多角形のときは、リージョンハンドルを解放する */
  1264.         GMDisposeRgn((*temp1)->ext.rgn.hdl);
  1265.     MMHdlDispose(temp1);        /* データ登録用ハンドルを解放する */
  1266.  
  1267.     /* 選択図形をなしにする */
  1268.     pcv->actData = NULL;
  1269.  
  1270.     /* ラインのとき、線幅を考慮する */
  1271.     if (savType == 1) {
  1272.         rc.d.right += pt.p.x;
  1273.         rc.d.bottom += pt.p.y;
  1274.     }
  1275.  
  1276.     addUpdate(pcv->windowPtr, &rc);    /* 削除データを画面上からも消去する */
  1277. }
  1278.  
  1279. /******************************************************************************
  1280.  *    eraseData():    現在の指定図形を画面上から消去
  1281.  ******************************************************************************
  1282.  *    引数:    ComVal *pcv    共通変数へのポインタ
  1283.  */
  1284. void eraseData(ComVal *pcv)
  1285. {
  1286.     int savFlag;
  1287.     Rect rc;
  1288.     ComData **hcd = pcv->actData;
  1289.  
  1290.     /* 図形描画のため一時的に描画フラグを0にしておく */
  1291.     savFlag = pcv->animFlag;
  1292.     pcv->animFlag = 0;
  1293.  
  1294.     /* 選択されている図形を囲むレクタングルをグローバル座標系に変換する */
  1295.     rc = (*hcd)->bounds;
  1296.  
  1297.     if ((*hcd)->id == 1)
  1298.         checkRectPos(&rc);
  1299.     rc.d.left   -= 2;
  1300.     rc.d.top    -= 2;
  1301.     rc.d.right  += 2;
  1302.     rc.d.bottom += 2;
  1303.  
  1304.     /* 直線のとき、線幅を考慮する */
  1305.     if ((*hcd)->id == 1) {
  1306.         rc.d.right += (*hcd)->penSize.p.x;
  1307.         rc.d.bottom += (*hcd)->penSize.p.y;
  1308.         checkRectPos(&rc);
  1309.     }
  1310.  
  1311.     /* 削除データを画面上からも消去する */
  1312.     GMClipRect(&rc);
  1313.     drawGraph(pcv);
  1314.     GMClipRect(&pcv->windowPtr->graph.rect);
  1315.     pcv->animFlag = savFlag;
  1316. }
  1317.